Issues of Architectural Description Languages for Handling Dynamic Reconfiguration

Dynamic reconfiguration is the action of modifying a software system at runtime. Several works have been using architectural specification as the basis for dynamic reconfiguration. Indeed ADLs (architecture description languages) let architects describe the elements that could be reconfigured as well as the set of constraints to which the system must conform during reconfiguration. In this work, we investigate the ADL literature in order to illustrate how reconfiguration is supported in four well-known ADLs: pi-ADL, ACME, C2SADL and Dynamic Wright. From this review, we conclude that none of these ADLs: (i) addresses the issue of consistently reconfiguring both instances and types; (ii) takes into account the behaviour of architectural elements during reconfiguration; and (iii) provides support for assessing reconfiguration, e.g., verifying the transition against properties.Comment: 6\`eme Conf\'erence francophone sur les architectures logicielles (CAL'2012), Montpellier : France (2012

A Formal Architecture-Centric Model-Driven Approach for the Automatic Generation of Grid Applications

This paper discusses the concept of model-driven software engineering applied to the Grid application domain. As an extension to this concept, the approach described here, attempts to combine both formal architecture-centric and model-driven paradigms. It is a commonly recognized statement that Grid systems have seldom been designed using formal techniques although from past experience such techniques have shown advantages. This paper advocates a formal engineering approach to Grid system developments in an effort to contribute to the rigorous development of Grids software architectures. This approach addresses quality of service and cross-platform developments by applying the model-driven paradigm to a formal architecture-centric engineering method. This combination benefits from a formal semantic description power in addition to model-based transformations. The result of such a novel combined concept promotes the re-use of design models and facilitates developments in Grid computing.Comment: 11 pages, 9 figures. Proc of the 8th International Conference on Enterprise Information Systems (ICEIS06) Paphos, Cyprus. May 200

ASAS: An Approach to Support Simulation of Smart Systems

Smart systems, such as smart cities, smart buildings, and autonomous cars, have recently gained increasing popularity. Each such system is essentially a System-of-Systems (SoS). SoS are dynamically established as alliances among independent and heterogeneous software systems to offer complex functionalities as a result of constituents interoperability. An SoS often supports critical application domains, and, as such, must be reliable. Many SoS have been specified and evaluated for their correct operation using static models. However, speciï¬cation languages have not supported to capture their inherent dynamic nature nor enabled to monitor their operation. The main contribution of this paper is to present ASAS, an approach to Automatically generate Simulation models for smArt Systems (ASAS) in order to support evaluation of their operation. In particular, our approach makes it possible to transform formal models of the SoS architecture (expressed in SoSADL) into simulation models (expressed in DEVS). We evaluated our approach by conducting two case studies using a flood monitoring system that is intended to be part of a smart city. Results indicate that ASAS can successfully generate functional simulations for the SoS operation, which in turn can enable to reason and monitor an SoS operation, taking into account its dynamic nature

Composition-centered architectural pattern description language

International audienceArchitectural patterns are important artefacts containing specialized design knowledge to build good-quality systems. Complex systems often exhibit several architectural patterns in their design which leads to the need of architectural pattern composition. Unfortunately, information about the composition of patterns tend to be vaporized right after the composition process which causes problems of traceability and reconstructability of patterns. This paper proposes a pattern description language that first, facilitates several types of pattern merging operation and second, allows the traceability of pattern composition. More specifically, the approach consists of a proper description of pattern that supports composition operations and a two-step pattern design process that helps to preserve pattern composition information

Support for Evolving Software Architectures in the ArchWare ADL

Software that cannot evolve is condemned to atrophy: it cannot accommodate the constant revision and re-negotiation of its business goals nor intercept the potential of new technology. To accommodate change in software systems we have defined an active software architecture to be: dynamic in that the structure and cardinality of the components and interactions are changeable during execution; updatable in that components can be replaced; decomposable in that an executing system may be (partially) stopped and split up into its components and interactions; and reflective in that the specification of components and interactions may be evolved during execution. Here we describe the facilities of the ArchWare architecture description language (ADL) for specifying active architectures. The contribution of the work is the unique combination of concepts including: a {\pi}-calculus based communication and expression language for specifying executable architectures; hyper-code as an underlying representation of system execution that can be used for introspection; a decomposition operator to incrementally break up executing systems; and structural reflection for creating new components and binding them into running systems.Comment: 4th Working IEEE/IFIP Conference on Software Architecture (WICSA'04) pp.69-78, IEEE Computer Society, 200

Towards a Process to Design Architectures of Service-Oriented Robotic Systems

International audienceArchitecture description languages (ADLs) should consider both structural and runtime perspectives of software architectures, an important requirement for current software systems. However, most existing ADLs are disconnected from the runtime level, thus entailing architectural mismatches and inconsistencies between architecture and implementation. With the emergence of the new generation programming languages for large-scale, dynamic, and distributed systems, this problem becomes worse since most existing ADLs do not capture the features of this type of language. In this context, we investigate the generation of source code in the Go programming language from architecture descriptions in the π-ADL language as they are both based on the π-calculus process algebra. We define the correspondences between π-ADL and Go elements and present how architecture descriptions in π-ADL can be automatically translated to their respective implementations in Go through a real-world flood monitoring system